// filepath: /home/debi/IdeaProjects/LearnRust/Work/basic/src/stdx/ffix/cppx/bridge.cpp

/**
 * bridge.cpp - Rust 与 C++ FFI 桥接实现文件
 * 
 * 本文件实现了 bridge.h 中声明的 C++ 端函数
 * 这些函数可以被 Rust 代码通过 FFI 调用
 */

#include "bridge.h"
#include <cstring>
#include <cmath>
#include <iostream>
#include <sstream>
#include <iomanip>

// ============================================================================
// C 接口实现（extern "C"）
// ============================================================================

extern "C" {

/**
 * 实现简单的加法函数
 */
int32_t cpp_add(int32_t a, int32_t b) {
    std::cout << "[C++] cpp_add 被调用: " << a << " + " << b << std::endl;
    return a + b;
}

/**
 * 实现字符串处理函数
 * 在字符串前后添加标记
 */
char* cpp_process_string(const char* input) {
    // 检查空指针
    if (!input) {
        std::cerr << "[C++] cpp_process_string: 输入为空" << std::endl;
        return nullptr;
    }
    
    std::cout << "[C++] cpp_process_string 被调用: \"" << input << "\"" << std::endl;
    
    try {
        // 使用 C++ string 进行处理
        std::string str = "[C++] ";
        str += input;
        str += " [/C++]";
        
        // 分配新内存并复制结果
        char* result = new char[str.length() + 1];
        std::strcpy(result, str.c_str());
        
        std::cout << "[C++] 处理结果: \"" << result << "\"" << std::endl;
        return result;
        
    } catch (const std::exception& e) {
        std::cerr << "[C++] 异常: " << e.what() << std::endl;
        return nullptr;
    }
}

/**
 * 释放字符串内存（C++ 端分配的）
 */
void cpp_free_string(char* s) {
    if (s) {
        std::cout << "[C++] cpp_free_string 被调用" << std::endl;
        delete[] s;
    }
}

/**
 * 分配双精度浮点数组
 */
double* cpp_allocate_array(int32_t size) {
    std::cout << "[C++] cpp_allocate_array 被调用，大小: " << size << std::endl;
    
    if (size <= 0) {
        std::cerr << "[C++] 错误：数组大小必须为正数" << std::endl;
        return nullptr;
    }
    
    try {
        // 分配并初始化为 0
        double* arr = new double[size];
        std::memset(arr, 0, size * sizeof(double));
        return arr;
        
    } catch (const std::bad_alloc& e) {
        std::cerr << "[C++] 内存分配失败: " << e.what() << std::endl;
        return nullptr;
    }
}

/**
 * 释放数组内存
 */
void cpp_free_array(double* ptr) {
    if (ptr) {
        std::cout << "[C++] cpp_free_array 被调用" << std::endl;
        delete[] ptr;
    }
}

/**
 * 实现复杂的计算函数
 * 计算公式: x * y + sqrt(x) + y^2
 */
double cpp_calculate(double x, double y) {
    std::cout << "[C++] cpp_calculate 被调用: x=" << x << ", y=" << y << std::endl;
    
    double result = x * y + std::sqrt(x) + std::pow(y, 2);
    
    std::cout << "[C++] 计算结果: " << result << std::endl;
    return result;
}

/**
 * 处理复杂数据结构
 */
int32_t cpp_process_complex_data(const ComplexData* data) {
    // 检查空指针
    if (!data) {
        std::cerr << "[C++] cpp_process_complex_data: 数据指针为空" << std::endl;
        return -1;
    }
    
    std::cout << "[C++] cpp_process_complex_data 被调用" << std::endl;
    std::cout << "  ID: " << data->id << std::endl;
    std::cout << "  Value: " << std::fixed << std::setprecision(5) 
              << data->value << std::endl;
    std::cout << "  Name: " << data->name << std::endl;
    std::cout << "  Flags: 0x" << std::hex << data->flags << std::dec << std::endl;
    
    // 执行一些处理...
    if (data->id < 0) {
        std::cerr << "[C++] 错误：无效的 ID" << std::endl;
        return -2;
    }
    
    std::cout << "[C++] 数据处理成功" << std::endl;
    return 0;  // 成功
}

/**
 * 调用回调函数
 */
int32_t cpp_call_with_callback(Callback callback, int32_t value) {
    // 检查回调函数指针
    if (!callback) {
        std::cerr << "[C++] cpp_call_with_callback: 回调函数为空" << std::endl;
        return -1;
    }
    
    std::cout << "[C++] cpp_call_with_callback 被调用，值: " << value << std::endl;
    std::cout << "[C++] 准备调用 Rust 回调函数..." << std::endl;
    
    // 调用 Rust 提供的回调函数
    int32_t result = callback(value);
    
    std::cout << "[C++] 回调函数返回: " << result << std::endl;
    return result;
}

} // extern "C"

// ============================================================================
// C++ 专用实现（使用 C++ 特性）
// ============================================================================

namespace rust_cpp_bridge {

/**
 * 计算两点之间的距离
 */
double calculate_distance(const Point& p1, const Point& p2) {
    double dx = p2.x - p1.x;
    double dy = p2.y - p1.y;
    double distance = std::sqrt(dx * dx + dy * dy);
    
    std::cout << "[C++] 计算距离: (" << p1.x << ", " << p1.y << ") 到 ("
              << p2.x << ", " << p2.y << ") = " << distance << std::endl;
    
    return distance;
}

/**
 * 创建问候语
 */
std::string create_greeting(const Person& person) {
    std::ostringstream oss;
    oss << "Hello, " << person.name << "! You are " << person.age << " years old.";
    
    std::string greeting = oss.str();
    std::cout << "[C++] 创建问候语: " << greeting << std::endl;
    
    return greeting;
}

/**
 * 创建 CppVector 对象
 */
CppVector* create_cpp_vector() {
    std::cout << "[C++] 创建 CppVector 对象" << std::endl;
    return new CppVector();
}

} // namespace rust_cpp_bridge

// ============================================================================
// 测试主函数（可选）
// ============================================================================

#ifdef BUILD_TEST_MAIN

/**
 * 声明 Rust 函数用于测试
 */
extern "C" {
    int32_t rust_multiply(int32_t a, int32_t b);
    char* rust_concat_strings(const char* s1, const char* s2);
    void rust_free_string(char* s);
    double rust_sum_array(const double* arr, int32_t len);
    int32_t rust_callback_double(int32_t x);
}

int main() {
    std::cout << "╔════════════════════════════════════════════════════════╗" << std::endl;
    std::cout << "║     Rust-C++ FFI 桥接测试程序                        ║" << std::endl;
    std::cout << "╚════════════════════════════════════════════════════════╝" << std::endl;
    std::cout << std::endl;
    
    // 测试 1: 调用 Rust 的乘法函数
    std::cout << "=== 测试 1: 调用 Rust 函数 ===" << std::endl;
    int32_t mult_result = rust_multiply(6, 7);
    std::cout << "Rust multiply(6, 7) = " << mult_result << std::endl;
    std::cout << std::endl;
    
    // 测试 2: 调用 Rust 的字符串连接函数
    std::cout << "=== 测试 2: Rust 字符串处理 ===" << std::endl;
    const char* s1 = "Hello ";
    const char* s2 = "from C++!";
    char* concat_result = rust_concat_strings(s1, s2);
    if (concat_result) {
        std::cout << "Rust concat(\"" << s1 << "\", \"" << s2 << "\") = \"" 
                  << concat_result << "\"" << std::endl;
        rust_free_string(concat_result);
    }
    std::cout << std::endl;
    
    // 测试 3: 调用 Rust 的数组求和函数
    std::cout << "=== 测试 3: Rust 数组求和 ===" << std::endl;
    double numbers[] = {1.0, 2.0, 3.0, 4.0, 5.0};
    double sum = rust_sum_array(numbers, 5);
    std::cout << "Rust sum_array([1,2,3,4,5]) = " << sum << std::endl;
    std::cout << std::endl;
    
    // 测试 4: 测试 C++ 函数
    std::cout << "=== 测试 4: C++ 函数 ===" << std::endl;
    int32_t add_result = cpp_add(10, 20);
    std::cout << "cpp_add(10, 20) = " << add_result << std::endl;
    
    double calc_result = cpp_calculate(4.0, 3.0);
    std::cout << "cpp_calculate(4.0, 3.0) = " << calc_result << std::endl;
    std::cout << std::endl;
    
    // 测试 5: 回调函数
    std::cout << "=== 测试 5: 回调函数 ===" << std::endl;
    int32_t callback_result = cpp_call_with_callback(rust_callback_double, 10);
    std::cout << "使用 Rust 回调函数，结果: " << callback_result << std::endl;
    std::cout << std::endl;
    
    // 测试 6: 复杂数据结构
    std::cout << "=== 测试 6: 复杂数据结构 ===" << std::endl;
    ComplexData data;
    data.id = 1001;
    data.value = 3.14159;
    std::strcpy(data.name, "TestData");
    data.flags = 0x05;
    
    int32_t process_result = cpp_process_complex_data(&data);
    std::cout << "处理结果: " << process_result << std::endl;
    std::cout << std::endl;
    
    std::cout << "所有测试完成！" << std::endl;
    return 0;
}

#endif // BUILD_TEST_MAIN

// ============================================================================
// 编译命令示例
// ============================================================================

/*
编译为动态库（Linux）：
g++ -shared -fPIC -o libbridge.so bridge.cpp -std=c++14 -Wall -Wextra

编译为动态库（macOS）：
clang++ -dynamiclib -o libbridge.dylib bridge.cpp -std=c++14 -Wall -Wextra

编译为静态库：
g++ -c bridge.cpp -std=c++14 -o bridge.o
ar rcs libbridge.a bridge.o

编译测试程序（需要链接 Rust 静态库）：
g++ -DBUILD_TEST_MAIN bridge.cpp -o test_bridge -std=c++14 -L./target/debug -lbasic -lpthread -ldl

使用说明：

1. 在 Rust 项目的 build.rs 中添加：
   ```rust
   fn main() {
       cc::Build::new()
           .cpp(true)
           .file("src/stdx/ffix/cppx/bridge.cpp")
           .flag("-std=c++14")
           .compile("bridge");
       
       println!("cargo:rerun-if-changed=src/stdx/ffix/cppx/bridge.cpp");
       println!("cargo:rerun-if-changed=src/stdx/ffix/cppx/bridge.h");
   }
   ```

2. 在 Cargo.toml 中添加：
   ```toml
   [build-dependencies]
   cc = "1.0"
   ```

3. 运行 Rust 程序：
   ```bash
   cargo build
   cargo run
   ```

注意事项：
- 确保 C++ 代码不会抛出异常到 Rust 端
- 所有通过 FFI 传递的类型必须是 C 兼容的
- 内存管理要遵循"谁分配谁释放"的原则
- 字符串必须是 null 结尾的 C 字符串
- 使用 extern "C" 避免名称修饰
*/

